package test;

	/*
	Java HashMap example.
	This Java HashMap example describes the basic operations performed on the HashMap.
	*/
	import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
	public class HashMaps
	{
		public static void main(String args[])
		{
			// constructs a new empty HashMap with default initial capacity
		
			HashMap hashMap = new HashMap();
			/*
			To specify initial capacity, use following constructor.
			HashMap HashMap = new HashMap(100);
			To create HashMap from map use following constructor
			HashMap HashMap = new HashMap(Map myMap);
			*/
			hashMap.put( "One", new Integer(1) ); // adding value into HashMap
			hashMap.put( "Two", new Integer(2) );
			hashMap.put( "Three", new Integer(3) );
			/*
			IMPORTANT : We CAN NOT add primitives to the HashMap. We have to wrap it into one of the wrapper before adding.
			*/
			/*
			To copy all key - value pairs from any Map to HashMap use putAll method.
			Signature of putAll method is,
			void putAll(Map m)
			*/
			//get number of keys present in the HashMap
			System.out.println("HashMap contains " + hashMap.size() + " key value pair.");
			/*
			To check whether HashMap is empty or not, use isEmpty() method.
			isEmpty() returns true is HashMap is empty, otherwise false.
			/*
			Finding particular value from the HashMap :
			HashMap's containsValue method returns boolean depending upon the presense of the value in given HashMap
			Signature of the containsValue method is,
			boolean containsValue(Object value)
			*/
			if( hashMap.containsValue( new Integer(1) ) )
			{
				System.out.println("HashMap contains 1 as value");
			}
			else
			{
				System.out.println("HashMap does not contain 1 as value");
			}
			/*
			Finding particular Key from the HashMap :
			HashMap's containsKey method returns boolean depending upon the presense of the key in given HashMap
			Signature of the method is,
			boolean containsKey(Object key)
			*/
			if( hashMap.containsKey("One") )
			{
				System.out.println("HashMap contains One as key");
			}
			else
			{
				System.out.println("HashMap does not contain One as value");
			}
			/*
			Use get method of HashMap to get value mapped to particular key.
			Signature of the get method is,
			Object get(Object key)
			*/
			Integer one = (Integer) hashMap.get("One");
			System.out.println("Value mapped with key \"One\" is " + one);
			/*
			IMPORTANT:  get method returns Object, so we need to downcast it.
			*/
			
	        Set<String> KEYSET1 = hashMap.keySet();
	        Object[] KEYS1 = KEYSET1.toArray();

	        /** iterate over hashMap with for-loop in one way **/
	        for (int counter=0; counter<KEYS1.length; ++counter)
			{
	        	Object OBJECT = hashMap.get(KEYS1[counter]);
	        	System.out.println(OBJECT);
			}

	        /** iterate over hashMap with for-loop (just another way of doing the same) **/
	        for ( Object OBJECT : KEYSET1 )
	        {
	       		System.out.println(hashMap.get(OBJECT));
	        }

	        /** iterate over hashMap with while-loop way **/
			Iterator<Enum> iterator = hashMap.keySet().iterator();
			while(iterator.hasNext())
			{
				Object key = iterator.next();
				Object val = hashMap.get(key);
				System.out.println(val);
			}
			
			/*
			To get all keys stored in HashMap use keySet method.
			Signature of the keysSet method is,
			Set keySet()
			*/
			System.out.println("Retriving all keys from the HashMap");
			Iterator iterator1 = hashMap.keySet().iterator();
			while( iterator1. hasNext() )
			{
				System.out.println( iterator1.next() );
			}
			/*
			To get all values stored in HashMap use entrySet() method.
			Signature of the entrySet() method is,
			Set entrySet()
			*/
			System.out.println("Retriving all values from the HashMap");
			iterator1 = hashMap.entrySet().iterator();
			while( iterator1. hasNext() )
			{
				System.out.println( iterator1.next() );
			}
			/*
			To remove particular key - value pair from the HashMap use remove method.
			Signature of remove methid is,
			Object remove(Object key)
			This method returns value that had mapped to the given key, otherwise null if mapping not found.
			*/
			System.out.println( hashMap.remove("One") + " is removed from the HashMap.");
			
			/** extract keys of a hashMap **/
            Set<String> KEYSET = hashMap.keySet();
            
            /** convert key-set to array of key objects **/
            Object[] KEYS = KEYSET.toArray();
            
            func1();
		}
		
		static void func1()
		{
			/** falls man nach einer möglichkeit sucht assoziative arrays zu basteln, wie das in PHP oder AS3/Flex möglich ist 
			 * muss man sich der HashMaps bedienen.
			 */
			// ref["hello"] = "Hello World"; // geht nicht

			/**
			 * •	V put( K key, V value ) Speichert den Schlüssel und den Wert in der Hash-Tabelle.
			 * 	Falls sich zu diesem Schlüssel schon ein Eintrag in der Hash-Tabelle befand,
			 * wird der alte Wert überschrieben und der vorherige Wert zum Schlüssel zurückgegeben.
			 * Ist der Schlüssel neu, liefert put() den Rückgabewert null.
			 * Das heißt natürlich auch, dass mit put(key, value) == null nicht klar ist,
			 * ob put() einen Wert überschreibt und der alte Wert null war,
			 * oder ob noch kein Schlüssel-Werte-Paar in dem Assoziativspeicher lag.
			 */
			Map<String,String> aldiSupplier = new HashMap<String,String>(); 
			aldiSupplier.put( "Carbo, spanischer Sekt", "Freixenet" ); 
			aldiSupplier.put( "ibu Stapelchips", "Bahlsen Chipsletten" ); 
			aldiSupplier.put( "Ko-kra Katzenfutter", "felix Katzenfutter" ); 
			aldiSupplier.put( "Küchenpapier", "Zewa" ); 
			aldiSupplier.put( "Nuss-Nougat-Creme", "Zentis" ); 
			aldiSupplier.put( "Pommes Frites", "McCaine" );
			/**
			 * Die zweite HashMap soll Strings mit Zahlen assoziieren:
			 */
			Map<String,Number> num = new HashMap<String,Number>(); 
			num.put( "zwei", 2 );    // Durch Boxing in Integer(2) 
			num.put( "drei", 3.0 );  // dito. Double(3)

			/**
			 * Fügt alle Schlüssel-Werte-Paare aus m in die aktuelle Map ein. Auch diese Methode überschreibt unter Umständen vorhandene Schlüssel.
			 */
			// void putAll( Map<? extends K, ? extends V> m );

			/**
			 * READ1: Daten auslesen
			 * Um wieder ein Element auszulesen, verwenden wir get(key). Das Argument identifiziert das zu findende Objekt über den Schlüssel, in dem das Objekt herausgesucht wird, das den gleichen Hashwert besitzt und im Sinne von equals() gleich ist. Wenn das Objekt nicht vorhanden ist, ist die Rückgabe null. Allerdings kann auch null der mit einem Schlüssel assoziierte Wert sein, denn null ist als Wert durchaus erlaubt.
			 * Beispiel Erfrage den Assoziativspeicher nach »zwei«. Das Ergebnis wird ein Number-Objekt sein:
			 */
			boolean result = num.containsKey("zwei");
			
			System.out.println( result );

			Number number = num.get( "zwei" ); 
			if ( number != null )
			{
				System.out.println( number.intValue() );
			}
			
			Object object = num.get( "zwei" ); 
			if ( number != null )
			{
				System.out.println( number.intValue() );
			}
			/**
			 * Mit Generics kann eine Typanpassung entfallen, wenn – wie in unserem Beispiel – Number-Objekte mit dem String assoziiert waren. Wurde der Typ nicht angegeben, ist eine Typanpassung nötig.
			 */
			/**
			 * READ2: for loop
			 * iterates through hashmap, returns keys.
			 */
			for ( String elem : aldiSupplier.keySet() )
			{
				System.out.println( elem );
			}
			/**
			 * READ3: for loop
			 * iterates through hashmap, returns values.
			 */
			for ( String elem : aldiSupplier.keySet() )
			{
				System.out.println( aldiSupplier.get(elem) );
			}
			
			/** iterate over hashMap via for loop by array-keyset **/
            Set<String> KEYSET = aldiSupplier.keySet();
            Object[] KEYS = KEYSET.toArray();

            /** iterate over aldiSupplier **/
            for (int counter=0; counter<KEYS.length; ++counter)
			{
            	Object OBJECT = aldiSupplier.get(KEYS[counter]);
            	// HashMap OBJECT = (HashMap) aldiSupplier(KEYS[counter]); // cast to hashmap
            	System.out.println(OBJECT);
			}

            /** iterate over aldiSupplier **/
            Iterator iterator_aldiSupplier = aldiSupplier.keySet().iterator();
			while( iterator_aldiSupplier.hasNext() )
			{
				Object OBJECT = iterator_aldiSupplier.next();
			}
		}
	}
	/*
	OUTPUT of the above given Java HashMap Example would be :
	HashMap contains 3 key value pair.
	HashMap contains 1 as value
	HashMap contains One as key
	Value mapped with key "One" is 1
	Retriving all keys from the HashMap
	Three
	Two
	One
	Retriving all values from the HashMap
	Three=3
	Two=2
	One=1
	1 is removed from the HashMap.
	*/